// 筛出全天和非全天的事件
export const filterDay = (arr) => {
    // 遍历数组找出数组中含有交集的数据
    let key = 0;
    let sameDayArr = [] // 不是一整天的事件
    let allDayArr = [] // 一整天的事件
    while (key < arr.length) {
        const actionStartTime = new Date(arr[key].actionStartTime)
        const actionEndTime = new Date(arr[key].actionEndTime)
        const leaseTime = (actionEndTime.getTime() - actionStartTime.getTime()) / 1000
        if (leaseTime <= 86400 && actionStartTime.getDate() == actionEndTime.getDate() && !arr[key].isAllDay) {
            sameDayArr.push(arr[key])
        } else {
            allDayArr.push(arr[key])
        }
        arr[key] = formatTime(arr[key])
        key++
    }
    return {
        deArr: arr,
        sameDayArr,
        allDayArr
    }
}
let day_this = new Date().getTime();
/**
 * format time
 * @param {*} data 事件
 */
export const formatTime = (data) => {
    const actionStartTime = new Date(data.actionStartTime)
    const actionEndTime = new Date(data.actionEndTime)
    const leaseTime = (actionEndTime.getTime() - actionStartTime.getTime()) / 1000
    let sameDay = false
    if (leaseTime <= 86400 && actionStartTime.getDate() == actionEndTime.getDate() && !data.isAllDay) {
        sameDay = true
    }

    // 跨天事件写在这里 这里的逻辑有问题要重新写
    // 简单来说就是日期不同且不从0：00开始就算跨天
  
    let startDateThis = data.actionStartTime.split(' ')[0].split("-")[2].trim();
    let endDateThis = data.actionEndTime.split(' ')[0].split("-")[2].trim();
    let kua = 0
    // if(data.id=="1640565457185910786"){
    //     debugger
    // }
  
    
    // if(leaseTime>86400){
        
    // }
    
    data.start = actionStartTime.getTime()
    data.end = actionEndTime.getTime()
    data.sameDay = sameDay
   
    data.startDate = data.actionStartTime.split(' ')[0]
    data.endDate = data.actionEndTime.split(' ')[0]
    data.startDay = actionStartTime.getDay()
    data.endDay = actionEndTime.getDay()
    if(data.end<day_this){
        // 说明逾期了
        data.yuqi = 1
    }
    const startHour = data.actionStartTime.split(' ')[1]
    const endHour = data.actionEndTime.split(' ')[1]
    const startHourSplit = startHour.split(':')
    const endHourSplit = endHour.split(':')
    data.startHour = Number(startHourSplit[0]) * 60 * 60 + Number(startHourSplit[1]) * 60 + (Number(startHourSplit[2]) ? Number(startHourSplit[2]) : 0)

    data.endHour = Number(endHourSplit[0]) * 60 * 60 + Number(endHourSplit[1]) * 60 + (Number(endHourSplit[2]) ? Number(endHourSplit[2]) : 0)
    data.hours = startHour + ' - ' + endHour
    data.release = data.end - data.start
    if((startDateThis!=endDateThis)){
        // 下周重点关注这里 00：00：00 24小时01秒
        if(data.hours=="00:00:00 - 00:00:00"){
            if(data.release>86400){
                kua = 1
            }else{
                kua = 0
            }
        }else{ 
            kua = 1

        }
    }
    data.kua = kua
    return data
}
/**
 * reset time
 * @info 事件
 * @time 移动的时间
 * @k 事件的时间长度
 */
// eslint-disable-next-line no-unused-vars
export const resetTime = (info, time, k) => {
    const startHour = info.actionStartTime.split(' ')[1]
    const actionStartTime = formatDay(time + ' ' + startHour + ':00', 0)
    const actionEndTime = formatDay(time + ' ' + startHour + ':00', k)
    info.actionStartTime = actionStartTime
    info.actionEndTime = actionEndTime
    info = formatTime(info)
    return info
}
/**
 * 返回所传的周内的事件
 * @param {*} arr 所有事件
 * @param {*} week 周
 * @returns 
 */
export const checkCurrentWeekEvents = (arr, week) => {
    if (!week && week.length < 1) return []
    const startWeek = new Date(week[0].fullDate + ' 00:00:00').getTime()
    const endWeek = new Date(week[week.length - 1].fullDate + ' 23:59:59').getTime()
    let deArr = []
    let i = 0
    while (i < arr.length) {
        // 如果一个时间: 起始时间大于周结束时间, 不在本周
        //              起始时间小于周开始时间, 结束时间小于周开始时间, 不在本周
        //              结束时间小于周开始时间, 不在本周
        // 那么: 起始时间大于周开始时间, 结束时间小于周结束时间在本周
        //       起始时间大于周开始时间, 结束时间大于周结束时间, 起始时间小于周结束时间
        //       起始时间小于周开始时间, 结束时间大于周结束时间, 也在本周内
        //       起始时间小于周开始时间, 结束时间小于周结束时间, 结束时间大于周开始时间
        const start = arr[i].start
        const end = arr[i].end
        if (
            (start >= startWeek && end <= endWeek) ||
            (start >= startWeek && end >= endWeek && start <= endWeek) ||
            (start <= startWeek && end >= endWeek) ||
            (start <= startWeek && end <= endWeek && end >= startWeek)
        ) {
            deArr.push(arr[i])
        }
        i++
    }
    return deArr
}

// 定义一个定格下标
let num = 0
// 做一个 一月份的3维矩阵 

let arcLength = [
    // [[], [], [], [], [],[], []],
    // [[], [], [], [], [], [], []],
    // [[], [], [], [], [], [], []],
    // [[], [], [], [], [], [], []],
    // [[], [], [], [], [], [], []]

];




/**
 * 获取在任意一天的事件
 * @param {*} date 
 * @param {*} events 
 * @param {*} str 
 * @param {*} AddTime 添加的时间
 * @returns 
 */
export const getAnyTimeEvent = (date, events, str = 'day', AddTime = 0) => {
    let start = null
    let end = null
    if (!date) {
        start = new Date(new Date().toLocaleDateString()).getTime()
        end = start + 24 * 60 * 60 * 1000 - 1
    } else {
        if (typeof date !== 'object') {
            date = date.replace(/-/g, '/')
        }
        if (str == 'day') {
            num = num + 1;
            
            start = new Date(new Date(date).toLocaleDateString()).getTime()
            end = start + 24 * 60 * 60 * 1000 - 1
        } else if (str == 'time') {
          
            // 根据1小时获取
            start = new Date(date).getTime()
            if (AddTime) {
                end = start + AddTime
            } else {
                // 默认1小时
                end = start + 60 * 60 * 1000 - 1
            }
        }
    }
    let deArr = [] // 结果数据
    for (let i = 0; i < events.length; i++) {
        const event_start = events[i].start
        const event_end = events[i].end
        if (
            (event_start >= start && event_end <= end) ||
            (event_start >= start && event_end >= end && event_start <= end) ||
            (event_start <= start && event_end >= end) ||
            (event_start <= start && event_end <= end && event_end >= start)
        ) {
            // 这里先不要push先判断一道是否是最后一天
            // 先把开始时间和结束时间的天数算出来
            // 判断s
              deArr.push(events[i])
            // if(str = 'day'){
            //     先把开始时间和结束时间的天数算出来
            // let begin = events[i].actionStartTime.split(" ")[0].split("-")[2];
            // let end = events[i].actionEndTime.split(" ")[0].split("-")[2];
            // if(Number(end)>Number(begin)){
            //     // 这是跨天来算的
            //     let ev = events[i];
            //     ev.kua = 1;
            //     arcLength.push(ev);
            // }else{
            //     // 非跨天
            //     let ev = events[i];
            //     ev.kua = 0;
            //     arcLength.push(ev);
            // }
            // }
           
        }
    }

    // 筛选出两个位置  一个是没有跨天的 一个是跨天的 每个num循环之前的num
    // kua ={ } nokua={ } 在楼上筛选

    // 排序依次递进的  
    if(num===35){
        num = 0
    }
    return deArr
}


export const getAnyTimeEventNumber = (date, events, str = 'day', AddTime = 0) => {
    let start = null
    let end = null
    if (!date) {
        start = new Date(new Date().toLocaleDateString()).getTime()
        end = start + 24 * 60 * 60 * 1000 - 1
    } else {
        if (typeof date !== 'object') {
            date = date.replace(/-/g, '/')
        }
        if (str == 'day') {
            num = num + 1;
            
            start = new Date(new Date(date).toLocaleDateString()).getTime()
            end = start + 24 * 60 * 60 * 1000 - 1
        } else if (str == 'time') {
          
            // 根据1小时获取
            start = new Date(date).getTime()
            if (AddTime) {
                end = start + AddTime
            } else {
                // 默认1小时
                end = start + 60 * 60 * 1000 - 1
            }
        }
    }
    // 检索的时候加入weileistart
    let deArr = [] // 结果数据
    for (let i = 0; i < events.length; i++) {
        const event_start = events[i].start;
        const event_end = events[i].end
        if (
            (event_start >= start && event_end <= end) ||
            (event_start >= start && event_end >= end && event_start <= end) ||
            (event_start <= start && event_end >= end) ||
            (event_start <= start && event_end <= end && event_end >= start)
        ) {
                
            let hours = events[i].hours.split("-");
            let hoursStart =hours[0].trim()
            let hoursEnd =hours[1].trim()
            var copyDate = date;
            copyDate = copyDate.split('/');
            copyDate = copyDate[0]+"-"+ copyDate[1]+"-"+ copyDate[2];
          
            // 这里有个不成文的算法 如果0：00 - 0：00 有可能会有问题
            if(hoursStart==="00:00:00"&&hoursEnd==="00:00:00"&&events[i].endDate===copyDate){
               
                // 这里就过滤掉了
              }else{
                deArr.push(events[i])
              }
           
        }
    }
    return deArr
}



// 重写返回数量方法，返回全部个数，剩余个数

/**
 * 1、获取到最大值
 * 2、获取到总数量
 * 3、上午下午分出来放入数组中
*/

export const getOverNUmber = (date, events, str = 'day', AddTime = 0) => {
    // 获取到当前数组
    let base = getAnyTimeEventNumber(date,events,str,AddTime);
    
    // 这里要将00点的排除在外



    // 将上下午分出来
    let top = [];
    let bottom = [];
    let toponther = [];
    let bottomonther = [];
    for(let i = 0 ; i <base.length;i++){
        // 如果大于 >= 43200 为下午否则为上午
        if(base[i].startHour>= 43200){
            if(bottom.length-1<2){
                bottom.push(base[i])
            }else{
                bottomonther.push(base[i])
            }
        }else{
            if(top.length-1<2){
                top.push(base[i])
            }else{
                toponther.push(base[i])
            }
        }
    }
    // 更多事件  分为上下午 上午几件 下午几件
    // 全部事件
    const moreAnd  = toponther.length + bottomonther.length
    return {
        countNumber:base.length,
        top,
        bottom,
        moreAnd,
        toponther:toponther.length,
        bottomonther:bottomonther.length
    }
}

/**
 * 格式化事件 
 * @date 日期
 * @k 增加的时间
 */
export const formatDay = (date, k) => {
    let time = new Date(date).getTime()
    time += k
    const afterDate = new Date(time)
    const year = afterDate.getFullYear()
    let month = afterDate.getMonth() + 1
    let day = afterDate.getDate()
    let hour = afterDate.getHours()
    let min = afterDate.getMinutes()
    if (month < 10) month = '0' + month
    if (day < 10) day = '0' + day
    if (hour < 10) hour = '0' + hour
    if (min < 10) min = '0' + min
    return year + '-' + month + '-' + day + ' ' + hour + ':' + min
}